﻿using cszmcaux;
using System.Text;
using static cszmcaux.Zmcaux;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;



namespace Zmotion406
{
    public partial class Form1 : Form
    {
        public IntPtr handle;//定义一个IntPtr类型的变量来保存控制器的句柄

        public int axis { get; set; }         //轴号
        public enum Axis { X, Y, Z }
        private Axis currentAxis = Axis.X; // 默认选中X轴

        public List<System.Windows.Forms.CheckBox> ListcheckBoxs = new List<System.Windows.Forms.CheckBox>();//定义一个List来保存复选框
        public List<System.Windows.Forms.CheckBox> ListIncheckBoxs = new List<System.Windows.Forms.CheckBox>();



        public Form1()
        {
            InitializeComponent();//初始化窗体


            InitializeDataGridView();//25.5.22初始化数据网格

        }


        /// <summary>
        /// 通过扫描当前网络下所有控制器的IP地址，并添加到下拉列表中
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_scanIP_Click(object sender, EventArgs e)
        {
            //清空下拉列表
            cmbIps.Items.Clear();

            //定义存储IP地址的数组
            var buffer = new StringBuilder();

            //搜索当前网络下控制器的IP
            int res = ZAux_SearchEthlist(buffer, 1024, 1000);
            if (res != 0)
            {
                MessageBox.Show("扫面IP失败！");
                return;
            }
            //根据空格分割出IP地址组成的数组
            var ips = buffer.ToString().Split(" ");

            //添加仿真环境IP地址到下拉列表中
            cmbIps.Items.Add("127.0.0.1");

            //循环把获取的IP地址添加到下拉列表中
            for (int i = 0; i < ips.Length - 1; i++)
            {
                cmbIps.Items.Add(ips[i]);
            }
            //默认选择第一个IP地址
            cmbIps.SelectedIndex = 0;
        }
        /// <summary>
        /// 连接与断开
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Connect_Click(object sender, EventArgs e)
        {
            var btnContent = Btn_Connect.Text;//    获取按钮的显示内容

            //根据按钮名称判断是连接还是断开
            if (object.Equals(btnContent, "连接"))
            {
                //获取连接的IP地址
                var ip = cmbIps.Text;

                //调用方法连接控制器
                int res = ZAux_OpenEth(ip, out handle);//连接控制器

                //判断是否连接成功
                if (res != 0)
                {
                    MessageBox.Show("连接失败！检查ip地址是否正确！");
                    return;
                }

                //修改按钮名称
                Btn_Connect.Text = "断开";
                //修改LED背景
                LED.BackColor = Color.LimeGreen;//绿色
                timer1.Enabled = true;      //连接成功打开定时器

            }
            else   //执行断开连接操作
            {

                //判断连接句柄是否为空
                if (handle != IntPtr.Zero)
                {
                    //关闭控制器连接
                    int res = ZAux_Close(handle);
                    if (res == 0)
                    {
                        //修改按钮的显示字符串
                        Btn_Connect.Text = "连接";

                        //修改LED背景
                        LED.BackColor = Color.DarkRed;//红色

                    }
                }
            }
        }
        /// <summary>
        /// 获取单轴运动的轴号
        /// </summary>
        /// <returns></returns>
        private int GetPrfAxis()
        {
            int result = -1;
            if (rad_X.Checked)
            {
                result = 0;
            }
            else if (rad_Y.Checked)
            {
                result = 1;
            }
            else if (rad_Z.Checked)
            {
                result = 2;
            }
            else if (rad_U.Checked)
            {
                result = 3;
            }
            return result;

        }

        #region 选择轴号--改变naxis
        private void axis_tox(object sender, EventArgs e)
        {
            //每次变更事件确实是触发了， 但是每次选中会触发， 取消选中也会触发的
            RadioButton radio = sender as RadioButton;
            //如果不是选中，就直接return了，不设置axis了
            if (!radio.Checked)
                return;

            axis = 0;
        }
        //好的， 目前还有一些可能性的问题， 就是这里这样控制起始不太好，最好是分开
        //你具体的业务我不清楚， 你可以先跑一边业务，我看下，然后我看下怎么修改比较合理
        private void axis_toy(object sender, EventArgs e)
        {
            RadioButton radio = sender as RadioButton;
            //如果不是选中，就直接return了，不设置axis了 (看到了吧，刚才这次是两个都走的， 如果不加判断，就会导致可能会有顺序的错误)
            if (!radio.Checked)
                return;
            axis = 1;
        }

        private void axis_toz(object sender, EventArgs e)
        {
            RadioButton radio = sender as RadioButton;
            //如果不是选中，就直接return了，不设置axis了
            if (!radio.Checked)
                return;
            axis = 2;
        }
        private void axis_tou(object sender, EventArgs e)
        {
            RadioButton radio = sender as RadioButton;
            //如果不是选中，就直接return了，不设置axis了
            if (!radio.Checked)
                return;
            axis = 3;
        }

        #endregion

        //private void Form1_Load(object sender, EventArgs e)
        //{
        //    UpdateRadioButtons(currentAxis);
        //}
        //private bool isSyncing = false; // 防止事件递归
        //private void UpdateRadioButtons(Axis axis)
        //{
        //    if (isSyncing) return;
        //    isSyncing = true;

        //    // TabPage1中的RadioButton
        //    rad_X.Checked = (axis == Axis.X);
        //    rad_Y.Checked = (axis == Axis.Y);
        //    rad_Z.Checked = (axis == Axis.Z);

        //    // TabPage2中的RadioButton
        //    radioButton4.Checked = (axis == Axis.X);
        //    radioButton5.Checked = (axis == Axis.Y);
        //    radioButton6.Checked = (axis == Axis.Z);

        //    currentAxis = axis;
        //    isSyncing = false;
        //}

        //不需要语音的， 在上班， 我等会就在这里说，你这里打字就行了
        //private void RadioButton_CheckedChanged(object sender, EventArgs e)
        //{
        //    if (sender is RadioButton rb && rb.Checked)
        //    {
        //        Axis selectedAxis = rb.Tag switch
        //        {
        //            "X" => Axis.X,
        //            "Y" => Axis.Y,
        //            "Z" => Axis.Z,
        //            _ => currentAxis
        //        };
        //        UpdateRadioButtons(selectedAxis);
        //    }
        //}

        /// <summary>
        /// 初始化控制器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Init_Click(object sender, EventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();


            //设置正限位
            ZAux_Direct_SetFwdIn(handle, axis, 2);

            //设置负限位
            ZAux_Direct_SetRevIn(handle, axis, 0);

            //设置原点
            ZAux_Direct_SetDatumIn(handle, axis, 1);

        }

        private void Btn_left_MouseDown(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //设置轴类型
            ZAux_Direct_SetAtype(handle, axis, 65);

            //设置运动曲线 起始速度，运动速度，加速度，减速度，S曲线，脉冲当量
            ZAux_Direct_SetLspeed(handle, axis, Convert.ToSingle(txt_Lspeed.Text));
            ZAux_Direct_SetSpeed(handle, axis, Convert.ToSingle(txtSpeed.Text));
            ZAux_Direct_SetAccel(handle, axis, Convert.ToSingle(txtAccl.Text));
            ZAux_Direct_SetDecel(handle, axis, Convert.ToSingle(txtDeccl.Text));
            ZAux_Direct_SetSramp(handle, axis, Convert.ToSingle(txt_Sramp.Text));
            ZAux_Direct_SetUnits(handle, axis, Convert.ToSingle(txtUnits.Text));

            //启动连续运动
            ZAux_Direct_Single_Vmove(handle, axis, -1);//-1表示正方向运动

        }
        private void Btn_right_MouseDown(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //设置轴类型
            ZAux_Direct_SetAtype(handle, axis, 65);

            //设置运动曲线 起始速度，运动速度，加速度，减速度，S曲线，脉冲当量
            ZAux_Direct_SetLspeed(handle, axis, Convert.ToSingle(txt_Lspeed.Text));
            ZAux_Direct_SetSpeed(handle, axis, Convert.ToSingle(txtSpeed.Text));
            ZAux_Direct_SetAccel(handle, axis, Convert.ToSingle(txtAccl.Text));
            ZAux_Direct_SetDecel(handle, axis, Convert.ToSingle(txtDeccl.Text));
            ZAux_Direct_SetSramp(handle, axis, Convert.ToSingle(txt_Sramp.Text));
            ZAux_Direct_SetUnits(handle, axis, Convert.ToSingle(txtUnits.Text));

            //启动连续运动
            ZAux_Direct_Single_Vmove(handle, axis, 1);// 1表示反方向运动
        }
        /// <summary>
        ///点动停止按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_left_MouseUp(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //停止规划轴对应运动
            if (handle != IntPtr.Zero)
            {
                int res = ZAux_Direct_Single_Cancel(handle, axis, 2);
                //if(res==0)
                //{
                //    MessageBox.Show($"{axis}轴停止成功！");
                //}
            }
        }

        // 定义一个标志变量，用于记录当前运动状态，false 表示停止，true 表示运动 
        private bool LeftisMoving = false;

        /// <summary>
        /// 左边单击连续运动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_left_continuous_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!LeftisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, axis, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, axis, -1); // -1 表示正方向运动 

                // 更新运动状态为正在运动 
                LeftisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, axis, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                LeftisMoving = false;
            }



        }

        // 定义一个标志变量，用于记录当前运动状态，false 表示停止，true 表示运动 
        private bool RightisMoving = false;
        /// <summary>
        /// 右边单击连续运动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_right_continuous_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!RightisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, axis, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, axis, 1); // 1 表示反方向运动 

                // 更新运动状态为正在运动 
                RightisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, axis, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                RightisMoving = false;
            }
        }
        /// <summary>
        /// 起始速度规定
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txt_Lspeed_TextChanged(object sender, EventArgs e)
        {
            //设置速度上限，不能超过10且要大于0
            //出现字符串或者值为空的情况下，打印提示信息，并将值设置为默认值
            if (string.IsNullOrEmpty(txt_Lspeed.Text))
            {
                MessageBox.Show("起始速度值不能为空，已设置为默认值1");
                txt_Lspeed.Text = "1";
                return;
            }

            if (!int.TryParse(txt_Lspeed.Text, out int speed))
            {
                MessageBox.Show("请输入有效的整数作为起始速度值");
                txt_Lspeed.Text = "1";
                return;
            }

            if (speed <= 0 || speed > 10)
            {
                MessageBox.Show("起始速度值必须大于0且不超过10，已设置为默认值1");
                txt_Lspeed.Text = "1";
                return;
            }


        }
        /// <summary>
        /// 运行速度规定   
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSpeed_TextChanged(object sender, EventArgs e)
        {
            //设置速度上限，不能超过10且要大于0
            //出现字符串或者值为空的情况下，打印提示信息，并将值设置为默认值

            if (string.IsNullOrEmpty(txtSpeed.Text))
            {
                MessageBox.Show("运行速度值不能为空，已设置为默认值10");
                txtSpeed.Text = "10";
                return;
            }

            if (!int.TryParse(txtSpeed.Text, out int speed))
            {
                MessageBox.Show("请输入有效的整数作为运行速度值");
                txtSpeed.Text = "10";
                return;
            }

            if (speed <= 0 || speed > 30)
            {
                MessageBox.Show("运行速度值必须大于0且不超过30，已设置为默认值10");
                txtSpeed.Text = "10";
                return;
            }
        }
        /// <summary>
        /// 加速度规定
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtAccl_TextChanged(object sender, EventArgs e)
        {

            //设置加速度上限，不能超过30且要大于0
            //出现字符串或者值为空的情况下，打印提示信息，并将值设置为默认值

            if (string.IsNullOrEmpty(txtAccl.Text))
            {
                MessageBox.Show("加速度值不能为空，已设置为默认值10");
                txtAccl.Text = "10";
                return;
            }

            if (!int.TryParse(txtAccl.Text, out int speed))
            {
                MessageBox.Show("请输入有效的整数作为加速度值");
                txtAccl.Text = "10";
                return;
            }

            if (speed <= 0 || speed > 30)
            {
                MessageBox.Show("加速度值必须大于0且不超过30，已设置为默认值10");
                txtAccl.Text = "10";
                return;
            }
        }
        /// <summary>
        /// 减速度规定
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtDeccl_TextChanged(object sender, EventArgs e)
        {

            //设置加速度上限，不能超过30且要大于0
            //出现字符串或者值为空的情况下，打印提示信息，并将值设置为默认值

            if (string.IsNullOrEmpty(txtDeccl.Text))
            {
                MessageBox.Show("减速度值不能为空，已设置为默认值10");
                txtDeccl.Text = "10";
                return;
            }

            if (!int.TryParse(txtDeccl.Text, out int speed))
            {
                MessageBox.Show("请输入有效的整数作为减速度值");
                txtDeccl.Text = "10";
                return;
            }

            if (speed <= 0 || speed > 30)
            {
                MessageBox.Show("减速度值必须大于0且不超过30，已设置为默认值10");
                txtDeccl.Text = "10";
                return;
            }
        }
        /// <summary>
        /// S曲线规定
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txt_Sramp_TextChanged(object sender, EventArgs e)
        {

            //设置S曲线上限，不能超过30且要大于0
            //出现非数字的情况下，打印提示信息，并将值设置为默认值

            try
            {

                if (string.IsNullOrEmpty(txt_Sramp.Text))
                {
                    throw new ArgumentException("输入不能为空");
                }

                int speed = int.Parse(txt_Sramp.Text);

                if (speed <= 0 || speed > 30)
                {
                    throw new ArgumentOutOfRangeException("S曲线值必须大于0且不超过30");
                }
            }
            catch (ArgumentException)
            {
                //处理输入为空的情况
                MessageBox.Show("输入不是有效数字，已设置为默认值10");
                txt_Sramp.Text = "10";
            }
            catch (FormatException)
            {
                //处理非数字的情况
                MessageBox.Show("输入不是有效数字，已设置为默认值10");
                txt_Sramp.Text = "10";
            }
            //catch (OverflowException)
            //{
            //    //处理溢出异常
            //    MessageBox.Show("输入值过大，已设置为默认值10");
            //    txt_Sramp.Text = "10";
            //}


        }
        /// <summary>
        /// 执行寸动功能的逻辑
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_PMove_Click(object sender, EventArgs e)
        {
            //获取规划轴的轴号 //这是在干嘛？ 你为啥你在外部定义的变量和内部定义的变量是一个名字？  非常不好的习惯
            //var axis = GetPrfAxis();

            //获取运动方向和模式【相对，绝对】
            var mode = rad_Relative.Checked ? 1 : -1;//1表示相对，-1表示绝对
            var dir = rad_Rev.Checked ? 1 : -1;//1表示反方向，-1表示正方向

            //获取运动参数
            var lspeed = Convert.ToSingle(txt_Lspeed.Text);//起始速度
            var speed = Convert.ToSingle(txtSpeed.Text);//运行速度
            var accel = Convert.ToSingle(txtAccl.Text);//加速度
            var decel = Convert.ToSingle(txtDeccl.Text);//减速度
            var sramp = Convert.ToSingle(txt_Sramp.Text);//S曲线
            var units = Convert.ToSingle(txtUnits.Text);//脉冲当量

            //设置运动参数
            ZAux_Direct_SetAtype(handle, axis, 65);//设置轴类型
            ZAux_Direct_SetLspeed(handle, axis, lspeed);//设置起始速度
            ZAux_Direct_SetSpeed(handle, axis, speed);//设置运行速度
            ZAux_Direct_SetAccel(handle, axis, accel);//设置加速度
            ZAux_Direct_SetDecel(handle, axis, decel);//设置减速度
            ZAux_Direct_SetSramp(handle, axis, sramp);//设置S曲线
            ZAux_Direct_SetUnits(handle, axis, units);//设置脉冲当量

            //快速减速速度

            ZAux_Direct_SetFastDec(handle, axis, 1000000000);

            //获取运动距离
            var distance = Convert.ToSingle(txt_Distance.Text);

            //根据运动模式执行相应的运动操作
            if (mode == 1) //相对运动
            {
                //如果距离为正，正方向运动，反之，反方向运动
                ZAux_Direct_Single_Move(handle, axis, distance * dir);//设置运动距离，正方向为正，反方向为负

            }
            else//绝对运动
            {
                ZAux_Direct_Single_MoveAbs(handle, axis, distance * dir);
            }


        }


        /// <summary>
        /// 把位置清0
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Zero_Click(object sender, EventArgs e)
        {

            //获取规划轴的轴号
            var axis = GetPrfAxis();

            if (handle != IntPtr.Zero)
            {
                //设置轴位置为0
                ZAux_Direct_SetDpos(handle, axis, 0);

            }
        }
        /// <summary>
        /// 停止运动功能
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Btn_Stop_Click(object sender, EventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            if (handle != IntPtr.Zero)
            {
                //停止规划轴对应运动
                ZAux_Direct_Single_Cancel(handle, axis, 2);


            }
        }
        /// <summary>
        /// 获取轴的当前位置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void textBox1_TextChanged(object sender, EventArgs e)
        {



        }


        /// <summary>
        /// 定时器，显示各个元件默认值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void timer1_Tick(object sender, EventArgs e)
        {

            int ret = 0;
            float[] f_axispara = new float[30];         //存储轴参数
            int[] i_axispara = new int[10];
            float B_Status = -1;                        //轴状态


            if (handle != IntPtr.Zero)//若已经连接到控制器
            {
                //获取轴的当前位置

                ret += ZAux_Direct_GetDpos(handle, 0, ref f_axispara[0]);
                ret += ZAux_Direct_GetDpos(handle, 1, ref f_axispara[1]);
                ret += ZAux_Direct_GetDpos(handle, 2, ref f_axispara[2]);

                // 获取轴的反馈位置 
                ret += ZAux_Direct_GetDpos(handle, 0, ref f_axispara[3]);
                ret += ZAux_Direct_GetDpos(handle, 1, ref f_axispara[4]);
                ret += ZAux_Direct_GetDpos(handle, 2, ref f_axispara[5]);

                //监控轴状态
                if (ret == 0)
                {
                    dpos0.Text = f_axispara[0].ToString();//当前位置
                    dpos1.Text = f_axispara[1].ToString();
                    dpos2.Text = f_axispara[2].ToString();

                    mpos0.Text = f_axispara[3].ToString();//反馈位置
                    mpos1.Text = f_axispara[4].ToString();
                    mpos2.Text = f_axispara[5].ToString();
                }


                // 回零界面数据监控显示
                if (axis == 0)
                {
                    textBox10.Text = i_axispara[0].ToString();
                    textBox11.Text = i_axispara[3].ToString();
                    textBox14.Text = f_axispara[6].ToString();
                    textBox12.Text = f_axispara[9].ToString();
                    textBox13.Text = f_axispara[12].ToString();
                }
                else if (axis == 1)
                {
                    textBox10.Text = i_axispara[1].ToString();
                    textBox11.Text = i_axispara[4].ToString();
                    textBox14.Text = f_axispara[7].ToString();
                    textBox12.Text = f_axispara[10].ToString();
                    textBox13.Text = f_axispara[13].ToString();
                }
                else
                {
                    textBox10.Text = i_axispara[2].ToString();
                    textBox11.Text = i_axispara[5].ToString();
                    textBox14.Text = f_axispara[8].ToString();
                    textBox12.Text = f_axispara[11].ToString();
                    textBox13.Text = f_axispara[14].ToString();
                }
                #region  定时器中显示XYZ数据
                ////获取XYZU坐标   01
                //int[] runstate = new int[4];
                //float[] curpos = new float[4];

                //for (int i = 0; i < 4; i++)
                //{
                //    Zmcaux.ZAux_Direct_GetIfIdle(handle, i, ref runstate[i]);
                //    Zmcaux.ZAux_Direct_GetDpos(handle, i, ref curpos[i]);
                //}
                ////在dataGridView1中显示显示XYZU坐标
                //for (int i = 0; i < 4; i++)
                //{
                //    if (i == 0)
                //    {
                //        dataGridView1.Rows[i].Cells[0].Value = "X";
                //        dataGridView1.Rows[i].Cells[1].Value = curpos[i].ToString();
                //    }
                //    else if (i == 1)
                //    {
                //        dataGridView1.Rows[i].Cells[0].Value = "Y";
                //        dataGridView1.Rows[i].Cells[1].Value = curpos[i].ToString();
                //    }
                //    else if (i == 2)
                //    {
                //        dataGridView1.Rows[i].Cells[0].Value = "Z";
                //        dataGridView1.Rows[i].Cells[1].Value = curpos[i].ToString();
                //    }
                //    else if (i == 3)
                //    {
                //        dataGridView1.Rows[i].Cells[0].Value = "U";
                //        dataGridView1.Rows[i].Cells[1].Value = curpos[i].ToString();
                //    }
                //}

                #endregion
            }

        }

        /// <summary>
        ///  找原点模式(详情看详细说明)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show("0 清除所有轴的错误状态。\r\n1 轴以 CREEP 速度正向运行直到 Z 信号出现。碰到限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS。\r\n2 轴以 CREEP 速度反向运行直到 Z 信号出现。碰到限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS。\r\n3 轴以 SPEED 速度正向运行，直到碰到原点开关。然后轴以 CREEP 速度反向运动直到离开原点开关。找原点阶段碰到正限位开关会直接停止。爬行阶段碰到负限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS\r\n4 轴以 SPEED 速度反向运行，直到碰到原点开关。然后轴以 CREEP 速度正向运动直到离开原点开关。找原点阶段碰到负限位开关会直接停止。爬行阶段碰到正限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS。\r\n5 轴以 SPEED 速度正向运行，直到碰到原点开关。然后轴以 CREEP 速度反向运动直到离开原点开关，然后再继续以爬行速度反转直到碰到 Z 信号。碰到限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS。\r\n6 轴以 SPEED 速度反向运行，直到碰到原点开关。然后轴以 CREEP 速度正向运动直到离开原点开关，然后再继续以爬行速度正转直到碰到 Z 信号。碰到限位开关会直接停止。DPOS 值重置为 0 同时纠正 MPOS。\r\n8 轴以 SPEED 速度正向运行，直到碰到原点开关。碰到限位开关会直接停止。\r\n9 轴以 SPEED 速度反向运行，直到碰到原点开关。碰到限位开关会直接停止。\r\n21 使用 Ethercat 驱动器回零功能，此时 mode2 有效。设置驱动器回零方式（6098h），缺省 0 表示使用驱动器当前的回零方式。会使用轴的 SPEED, CREEP, ACCEL, DECEL，乘以UNITS 后自动设置驱动器的 6099h，609Ah动作时序：6098 回零方式→6099 速度→609A 加速度→6060 切换当前模式", "提示");

        }
        #region 回零功能
        /// <summary>
        /// 开始回零功能
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Start_returnzero_Click(object sender, EventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //回零开始按钮
            if (handle == (IntPtr)0)
            {
                MessageBox.Show("未连接控制器", "提示");
            }
            else
            {
                //开始设置轴参数
                try
                {
                    Zmcaux.ZAux_Direct_SetCreep(handle, 0, Convert.ToSingle(Returnzero_Creep.Text));//设置回零爬行速度
                    Zmcaux.ZAux_Direct_SetDatumIn(handle, axis, Convert.ToInt32(Returnzero_Yuandian.Text));//设置回零原点
                    Zmcaux.ZAux_Direct_SetFwdIn(handle, axis, Convert.ToInt32(Returnzero_Positive.Text));//设置回零正限位
                    Zmcaux.ZAux_Direct_SetRevIn(handle, axis, Convert.ToInt32(Returnzero_Nagetive.Text));//设置回零负限位
                    Zmcaux.ZAux_Direct_SetUnits(handle, axis, Convert.ToSingle(Returnzero_Pulse.Text));//设置脉冲当量
                                                                                                       //zmcaux.ZAux_Direct_SetAtype(g_handle, naxis, 7);设置轴类型

                    Zmcaux.ZAux_Direct_SetSpeed(handle, axis, Convert.ToSingle(Returnzero_Speed.Text));
                    Zmcaux.ZAux_Direct_SetAccel(handle, axis, Convert.ToSingle(Returnzero_Accl.Text));
                    Zmcaux.ZAux_Direct_SetDecel(handle, axis, Convert.ToSingle(Returnzero_Decel.Text));

                    if (checkBox1.Checked == true)      //原点信号反转
                    {
                        if (Convert.ToInt32(Returnzero_Yuandian.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Yuandian.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Yuandian.Text)].Checked = true;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Yuandian.Text), 1);
                            }
                        }
                    }
                    else
                    {
                        if (Convert.ToInt32(Returnzero_Yuandian.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Yuandian.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Yuandian.Text)].Checked = false;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Yuandian.Text), 0);
                            }
                        }
                    }
                    if (checkBox2.Checked == true)      //正限位信号反转
                    {
                        if (Convert.ToInt32(Returnzero_Positive.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Positive.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Positive.Text)].Checked = true;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Positive.Text), 1);
                            }
                        }
                    }
                    else
                    {
                        if (Convert.ToInt32(Returnzero_Positive.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Positive.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Positive.Text)].Checked = false;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Positive.Text), 0);
                            }
                        }
                    }
                    if (checkBox3.Checked == true)     //负限位信号反转
                    {
                        if (Convert.ToInt32(Returnzero_Nagetive.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Nagetive.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Nagetive.Text)].Checked = true;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Nagetive.Text), 1);
                            }
                        }
                    }
                    else
                    {
                        if (Convert.ToInt32(Returnzero_Nagetive.Text) >= 0)
                        {
                            if (Convert.ToInt32(Returnzero_Nagetive.Text) < 16)
                            {
                                ListcheckBoxs[Convert.ToInt32(Returnzero_Nagetive.Text)].Checked = false;
                            }
                            else
                            {
                                Zmcaux.ZAux_Direct_SetInvertIn(handle, Convert.ToInt32(Returnzero_Nagetive.Text), 0);
                            }
                        }
                    }

                    //回零
                    Zmcaux.ZAux_Direct_Single_Datum(handle, axis, Convert.ToInt32(textBox1.Text));
                }
                catch (Exception ex)
                {
                    MessageBox.Show("请输入正确的回零参数", "提示");

                }
            }
        }
        #endregion
        private void Move_stop_Click(object sender, EventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            #region 单轴运动停止
            if (handle == (IntPtr)0)
            {
                MessageBox.Show("未连接控制器", "提示");
            }
            else
            {
                Zmcaux.ZAux_Direct_Single_Cancel(handle, axis, 2);//停止规划轴对应运动
            }
            #endregion
        }

        #region   选择tabpage后同步radiobutton
        //还是写在tabpage标签切换的时候吧
        private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {

            if (tabControl1.SelectedIndex == 0)
            {
                //记录下当前选中的radiobutton 名称
                string radioText = "";
                //如果选择的是点击速度页面，就同步下电机位置比较的radiobutton
                foreach (var radio in groupBox12.Controls)
                {
                    if (radio is RadioButton)// 检查当前对象是否为RadioButton类型 
                    {
                        if (((RadioButton)radio).Checked)//如果当前radiobutton被选中
                        {
                            radioText = ((RadioButton)radio).Text;//记录下当前radiobutton的名称
                            break;
                        }

                    }
                }
                //找到当前界面的radiobutton，选中它
                foreach (var radio in groupBox1.Controls)
                {
                    if (radio is RadioButton)
                    {
                        if (radioText == ((RadioButton)radio).Text)
                        {
                            ((RadioButton)radio).Checked = true;
                            break;
                        }
                    }
                }
            }
            else if (tabControl1.SelectedIndex == 1)
            {
                //记录下当前选中的radiobutton 名称
                string radioText = "";
                //如果选择的是点击同步下电机位置页面，就比较速度的radiobutton
                foreach (var radio in groupBox1.Controls)
                {
                    if (radio is RadioButton)
                    {
                        if (((RadioButton)radio).Checked)
                        {
                            radioText = ((RadioButton)radio).Text;
                            break;
                        }

                    }
                }
                //找到当前界面的radiobutton，选中它
                foreach (var radio in groupBox12.Controls)
                {
                    if (radio is RadioButton)
                    {
                        if (radioText == ((RadioButton)radio).Text)
                        {
                            ((RadioButton)radio).Checked = true;
                            break;
                        }
                    }
                }
            }
        }
        #endregion

        #region  XYZ的事件点动功能



        // 设置位置、尺寸等属性...
        /// <summary>
        /// X1的点动功能
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_X1_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();


            //判断当前是否正在运动
            if (!LeftisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, 0, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, 0, -1); // -1 表示正方向运动 

                // 更新运动状态为正在运动 
                LeftisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, 0, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                LeftisMoving = false;
            }
            //5.29增加
            HandleAxisMovement(0, -1); // X轴负方向
        }
        /// <summary>
        /// X2的点动功能
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_X2_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!RightisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, 0, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, 0, 1); // 1 表示反方向运动 

                // 更新运动状态为正在运动 
                RightisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, 0, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                RightisMoving = false;
            }

            //5.29增加
            HandleAxisMovement(0, 1); // X轴正方向
        }

        private void btn_Y1_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();



            //判断当前是否正在运动
            if (!LeftisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, 1, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, 1, -1); // -1 表示正方向运动 

                // 更新运动状态为正在运动 
                LeftisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, 1, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                LeftisMoving = false;
            }

            HandleAxisMovement(1, -1);
        }

        private void btn_Y2_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!RightisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, 1, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, 1, 1); // 1 表示反方向运动 

                // 更新运动状态为正在运动 
                RightisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, 1, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                RightisMoving = false;
            }

            HandleAxisMovement(1, 1);
        }

        private void btn_Z1_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!LeftisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, axis, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, axis, -1); // -1 表示正方向运动 

                // 更新运动状态为正在运动 
                LeftisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, axis, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                LeftisMoving = false;
            }
            //5.29增加
            HandleAxisMovement(2, -1);
        }

        private void btn_Z2_MouseClick(object sender, MouseEventArgs e)
        {
            //获取规划轴的轴号
            var axis = GetPrfAxis();

            //判断当前是否正在运动
            if (!RightisMoving)
            {
                // 设置轴类型 
                ZAux_Direct_SetAtype(handle, axis, 65);

                // 启动连续运动 
                ZAux_Direct_Single_Vmove(handle, axis, 1); // 1 表示反方向运动 

                // 更新运动状态为正在运动 
                RightisMoving = true;
            }
            else
            {
                // 停止连续运动 
                ZAux_Direct_Single_Cancel(handle, axis, 2); // 2 表示停止当前运动 

                // 更新运动状态为停止 
                RightisMoving = false;
            }
            //5.29增加
            HandleAxisMovement(2, 1);
        }
        #endregion



        // 新增事件处理方法：按钮点击实现轴的运动 
        private void btn_X1_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(0, -1);
            //HandleStepMovement(0, 1);
        }

        private void btn_X2_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(0, 1);
            //HandleStepMovement(0, -1);
        }

        private void btn_Y1_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(1, -1);
            //HandleStepMovement(1, 1);
        }

        private void btn_Y2_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(1, 1);
            //HandleStepMovement(1, -1);
        }

        private void btn_Z1_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(2, -1);
            //HandleStepMovement(2, 1);
        }

        private void btn_Z2_Click(object sender, EventArgs e)
        {
            HandleAxisMovement(2, 1);
            //HandleStepMovement(2, -1);
        }

        //5.29 增加代码
        //新增变量用于记录轴的运动状态
        private bool[] axisMoving = new bool[3] { false, false, false }; // X, Y, Z 轴 
                                                                         // 新增通用运动方法
        private void HandleAxisMovement(int axis, int direction)
        {

            // 获取距离参数
            float distance = 0;
            bool hasValidDistance = float.TryParse(txt_Distance4.Text, out distance);

            if (hasValidDistance && distance != 0)
            {

                // 先停止该轴所有运动
                ZAux_Direct_Single_Cancel(handle, axis, 2);


                // 执行绝对运动模式
                // 设置运动参数（确保使用当前界面参数） 5.29新增

                ZAux_Direct_SetAtype(handle, axis, 65);
                ZAux_Direct_SetLspeed(handle, axis, Convert.ToSingle(txt_Lspeed.Text));
                ZAux_Direct_SetSpeed(handle, axis, Convert.ToSingle(txtSpeed.Text));
                ZAux_Direct_SetAccel(handle, axis, Convert.ToSingle(txtAccl.Text));
                ZAux_Direct_SetDecel(handle, axis, Convert.ToSingle(txtDeccl.Text));
                ZAux_Direct_Single_Move(handle, axis, distance * direction);
            }
            else
            {
                // 原有连续运动逻辑
                if (!axisMoving[axis])
                {
                    ZAux_Direct_SetAtype(handle, axis, 65);
                    ZAux_Direct_Single_Vmove(handle, axis, direction);
                    axisMoving[axis] = true;
                }
                else
                {
                    ZAux_Direct_Single_Cancel(handle, axis, 2);
                    axisMoving[axis] = false;
                }
            }

            //if (!axisMoving[axis])
            //{
            //    // 设置轴类型 
            //    ZAux_Direct_SetAtype(handle, axis, 65);

            //    // 启动连续运动 
            //    ZAux_Direct_Single_Vmove(handle, axis, direction);

            //    // 更新运动状态为正在运动 
            //    axisMoving[axis] = true;

            //    // 更新DataGridView中显示的轴运动位置 
            //    UpdateAxisPositionInDataGridView(axis);
            //}
            //else
            //{
            //    // 停止连续运动 
            //    ZAux_Direct_Single_Cancel(handle, axis, 2);

            //    // 更新运动状态为停止 
            //    axisMoving[axis] = false;
            //}
        }


        #region  选择不同的插补运动
        // 新增事件处理方法：选择不同的插补运动 
        //private void radioButton11_CheckedChanged(object sender, EventArgs e)
        //{
        //    if (radioButton11.Checked)
        //    {
        //        // XY 直线 
        //        PerformInterpolationMovement(1);
        //    }
        //}

        //private void radioButton12_CheckedChanged(object sender, EventArgs e)
        //{
        //    if (radioButton12.Checked)
        //    {
        //        // XY 圆弧 
        //        PerformInterpolationMovement(2);
        //    }
        //}

        //private void radioButton13_CheckedChanged(object sender, EventArgs e)
        //{
        //    if (radioButton13.Checked)
        //    {
        //        // XYZ 直线 
        //        PerformInterpolationMovement(3);
        //    }
        //}

        //private void PerformInterpolationMovement(int mode)
        //{
        //    if (handle == (IntPtr)0)
        //    {
        //        MessageBox.Show("未链接到控制器!", "提示");
        //        return;
        //    }

        //    int[] axislist = { 0, 1, 2, 3 };
        //    float[] poslist = { 0, 0, 0, 0 };
        //    float[] midlist = { 0, 0, 0, 0 };
        //    float[] endmove = { 0, 0, 0, 0 };

        //    Zmcaux.ZAux_Direct_Base(handle, 4, axislist); // 选择运动轴列表 

        //    // 插补运动使用的是主轴参数，及 BASE 的第一个轴 
        //    Zmcaux.ZAux_Direct_SetSpeed(handle, axislist[0], Convert.ToSingle(textBox_Speed.Text));
        //    Zmcaux.ZAux_Direct_SetAccel(handle, axislist[0], Convert.ToSingle(textBox_Acc.Text));
        //    Zmcaux.ZAux_Direct_SetDecel(handle, axislist[0], Convert.ToSingle(textBox_Dec.Text));

        //    int run_mode = radioButton14.Checked ? 1 : -1; // 相对或绝对运动 

        //    if (run_mode == 1) // 绝对 
        //    {
        //        switch (mode)
        //        {
        //            case 1: // XY 直线 
        //                Zmcaux.ZAux_Direct_MoveAbs(handle, 2, axislist, poslist);
        //                break;
        //            case 2: // XY 圆弧 
        //                Zmcaux.ZAux_Direct_MoveCirc2Abs(handle, 2, axislist, midlist[0], midlist[1], poslist[0], poslist[1]);
        //                break;
        //            case 3: // XYZ 直线 
        //                Zmcaux.ZAux_Direct_MoveAbs(handle, 3, axislist, poslist);
        //                break;
        //            default:
        //                break;
        //        }
        //    }
        //    else
        //    {
        //        switch (mode)
        //        {
        //            case 1:
        //                Zmcaux.ZAux_Direct_Move(handle, 2, axislist, poslist);
        //                break;
        //            case 2:
        //                Zmcaux.ZAux_Direct_MoveCirc2(handle, 2, axislist, midlist[0], midlist[1], poslist[0], poslist[1]);
        //                break;
        //            case 3:
        //                Zmcaux.ZAux_Direct_Move(handle, 4, axislist, poslist);
        //                break;
        //            default:
        //                break;
        //        }
        //    }

        //    // 显示插补运动的轴位置 
        //    UpdateInterpolationPositionInDataGridView(mode);
        //}
        #endregion
        // 新增事件处理方法：选择相对运动或者绝对运动 
        private void radioButton14_CheckedChanged(object sender, EventArgs e)
        {
            // 可以在这里添加相应的逻辑 
        }

        private void radioButton15_CheckedChanged(object sender, EventArgs e)
        {
            // 可以在这里添加相应的逻辑 
        }










        private void UpdateAxisPositionInDataGridView(int axis)//更新轴的运动位置到 DataGridView
        {
            float[] curpos = new float[4];
            Zmcaux.ZAux_Direct_GetDpos(handle, axis, ref curpos[axis]);

            string axisName = "";
            switch (axis)
            {
                case 0:
                    axisName = "X";
                    break;
                case 1:
                    axisName = "Y";
                    break;
                case 2:
                    axisName = "Z";
                    break;
            }

            int newRowIndex = dataGridView1.Rows.Add();
            dataGridView1.Rows[newRowIndex].Cells[0].Value = $"P{newRowIndex + 1}点";
            dataGridView1.Rows[newRowIndex].Cells[axis + 1].Value = curpos[axis].ToString();
        }

        // 新增方法：更新插补运动的轴位置到 DataGridView 
        private void UpdateInterpolationPositionInDataGridView(int mode)
        {
            float[] curpos = new float[4];
            for (int i = 0; i < 4; i++)
            {
                Zmcaux.ZAux_Direct_GetDpos(handle, i, ref curpos[i]);
            }

            int newRowIndex = dataGridView1.Rows.Add();
            dataGridView1.Rows[newRowIndex].Cells[0].Value = $"P{newRowIndex + 1}点";
            dataGridView1.Rows[newRowIndex].Cells[1].Value = curpos[0].ToString();
            dataGridView1.Rows[newRowIndex].Cells[2].Value = curpos[1].ToString();
            dataGridView1.Rows[newRowIndex].Cells[3].Value = curpos[2].ToString();
            dataGridView1.Rows[newRowIndex].Cells[4].Value = curpos[3].ToString();
        }

        // 新增事件处理方法：增加 P 点位 
        private void btnAddPoint_Click(object sender, EventArgs e)
        {
            if (dataGridView1.Rows.Count < 100)
            {
                pointCount++; // 增加点位数量 

                // 初始化新的点位 
                dataGridView1.Rows.Add($"P{pointCount}点");
            }
            else
            {
                MessageBox.Show("最多只能添加 100 个点位。");
            }
        }

        // 新增事件处理方法：删除 P 点位 
        private void btnDeletePoint_Click(object sender, EventArgs e)
        {
            if (dataGridView1.SelectedRows.Count > 0)
            {
                foreach (DataGridViewRow row in dataGridView1.SelectedRows)
                {
                    if (!row.IsNewRow)
                    {
                        dataGridView1.Rows.Remove(row);
                    }
                }
                // 更新点位数量并重新命名点位 
                pointCount = dataGridView1.Rows.Count;
                for (int i = 0; i < dataGridView1.Rows.Count; i++)
                {
                    dataGridView1.Rows[i].Cells[0].Value = $"P{i + 1}点";
                }
            }
            else
            {
                MessageBox.Show("请先选择要删除的点位。");
            }
        }

        // 新增事件处理方法：保存获取到的点位信息 
        private void btnSavePoint_Click(object sender, EventArgs e)
        {
            // 模拟获取轴的点位信息 
            float[] curpos = new float[4];
            for (int i = 0; i < 4; i++)
            {
                Zmcaux.ZAux_Direct_GetDpos(handle, i, ref curpos[i]);
            }

            int newRowIndex = dataGridView1.Rows.Add();
            dataGridView1.Rows[newRowIndex].Cells[0].Value = $"P{newRowIndex + 1}点";
            dataGridView1.Rows[newRowIndex].Cells[1].Value = curpos[0].ToString();
            dataGridView1.Rows[newRowIndex].Cells[2].Value = curpos[1].ToString();
            dataGridView1.Rows[newRowIndex].Cells[3].Value = curpos[2].ToString();
            dataGridView1.Rows[newRowIndex].Cells[4].Value = curpos[3].ToString();
        }

        // 新增事件处理方法：运动刚才获取的点位信息 
        private void btnStart_Click(object sender, EventArgs e)
        {
            if (handle == (IntPtr)0)
            {
                MessageBox.Show("未链接到控制器!", "提示");
                return;
            }

            int[] axislist = { 0, 1, 2, 3 };
            float[] poslist = { 0, 0, 0, 0 };
            float[] midlist = { 0, 0, 0, 0 };
            float[] endmove = { 0, 0, 0, 0 };

            Zmcaux.ZAux_Direct_Base(handle, 4, axislist); // 选择运动轴列表 

            // 插补运动使用的是主轴参数，及 BASE 的第一个轴 
            Zmcaux.ZAux_Direct_SetSpeed(handle, axislist[0], Convert.ToSingle(textBox_Speed.Text));
            Zmcaux.ZAux_Direct_SetAccel(handle, axislist[0], Convert.ToSingle(textBox_Acc.Text));
            Zmcaux.ZAux_Direct_SetDecel(handle, axislist[0], Convert.ToSingle(textBox_Dec.Text));

            int run_mode = radioButton14.Checked ? 1 : -1; // 相对或绝对运动 

            foreach (DataGridViewRow row in dataGridView1.Rows)
            {
                if (!row.IsNewRow)
                {
                    poslist[0] = Convert.ToSingle(row.Cells["X"].Value);
                    poslist[1] = Convert.ToSingle(row.Cells["Y"].Value);
                    poslist[2] = Convert.ToSingle(row.Cells["Z"].Value);
                    poslist[3] = Convert.ToSingle(row.Cells["U"].Value);

                    if (run_mode == 1) // 绝对 
                    {
                        // 这里可以根据选择的插补运动模式进行相应的运动 
                        // 示例：XY 直线 
                        Zmcaux.ZAux_Direct_MoveAbs(handle, 2, axislist, poslist);
                    }
                    else
                    {
                        // 相对运动 
                        Zmcaux.ZAux_Direct_Move(handle, 2, axislist, poslist);
                    }
                }
            }
        }



        /// <summary>
        /// 初始化DataGridView   01
        /// </summary>
        /// 
        public int run_mode = 1;             //运动方式 相对OR绝对
        public int move_mode = 1;            //运行模式
        private int pointCount = 0;          // 用于跟踪点位的数量
        private void InitializeDataGridView()
        {
            // 设置DataGridView的行
            dataGridView1.Columns.Add("Name", "点位\\名字");
            dataGridView1.Columns.Add("X", "X坐标");
            dataGridView1.Columns.Add("Y", "Y坐标");
            dataGridView1.Columns.Add("Z", "Z坐标");
            dataGridView1.Columns.Add("U", "U坐标");
            //dataGridView1.Columns.Add("Speed", "速度");
            //dataGridView1.Columns.Add("Acceleration", "加速度");
            //dataGridView1.Columns.Add("Deceleration", "减速度");

            //dataGridView1.Columns[0].HeaderText = "点位";


            //设置DataGridView的列 
            // 初始化点位数量
            //pointCount = 10;

            //for (int point = 1; point <= pointCount; point++)
            //{
            //    dataGridView1.Rows.Add($"P{point}点");
            //}

            //// 初始化10个点位 
            //for (int i = 0; i < 10; i++)
            //{
            //    dataGridView1.Rows.Add();
            //}
        }


        #region  点位加运动
        /// <summary>
        /// 设置点位数量
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        //private void btnAddPoint_Click(object sender, EventArgs e)
        //{
        //    if (dataGridView1.Rows.Count < 100)
        //    {
        //        pointCount++;//增加点位数量
        //        // 初始化新的点位
        //        dataGridView1.Rows.Add($"P{pointCount}点");
        //    }
        //    else
        //    {
        //        MessageBox.Show("最多只能添加100个点位。");
        //    }
        //}

        //private void btnDeletePoint_Click(object sender, EventArgs e)
        //{

        //   // dataGridView1.Rows.Remove(dataGridView1.SelectedRows[0]);//删除选中的行
        //    if (dataGridView1.SelectedRows.Count > 0)
        //    {
        //        foreach (DataGridViewRow row in dataGridView1.SelectedRows)
        //        {
        //            if (!row.IsNewRow)
        //            {
        //                dataGridView1.Rows.Remove(row);
        //            }
        //        }
        //        // 更新点位数量并重新命名点位
        //        pointCount = dataGridView1.Rows.Count;
        //        for (int i = 0; i < dataGridView1.Rows.Count; i++)
        //        {
        //            dataGridView1.Rows[i].Cells[0].Value = $"P{i + 1}点";
        //        }
        //    }
        //    else
        //    {
        //        MessageBox.Show("请先选择要删除的点位。");
        //    }
        //}


        //private void btnSavePoint_Click(object sender, EventArgs e)
        //{
        //    // 模拟获取轴的点位信息 
        //    double x = 10.0; // 这里应该替换为实际的获取逻辑 
        //    double y = 20.0;
        //    double z = 30.0;
        //    double u = 40.0;
        //    double speed = 5.0;
        //    double acceleration = 2.0;
        //    double deceleration = 1.0;

        //    dataGridView1.Rows.Add(x, y, z, u, speed, acceleration, deceleration);
        //}

        //private void btnStart_Click(object sender, EventArgs e)
        //{
        //    if (handle == (IntPtr)0)
        //    {
        //        MessageBox.Show("未链接到控制器!", "提示");
        //    }
        //    else
        //    {
        //        int[] axislist = { 0, 1, 2, 3 };
        //        //设置一个数组 存储得到的XYZU坐标
        //        float[] midlist = { 0, 0, 0, 0 };
        //        float[] poslist = { 0, 0, 0, 0 };
        //          float[] endmove = { 0, 0, 0, 0 };              //相当绝对转换

        //        Zmcaux.ZAux_Direct_Base(handle, 4, axislist); //选择运动轴列表

        //        //插补运动使用的是主轴参数，及BASE的第一个轴
        //       Zmcaux.ZAux_Direct_SetSpeed(handle, axislist[0], Convert.ToSingle(textBox_Speed.Text));
        //       Zmcaux.ZAux_Direct_SetAccel(handle, axislist[0], Convert.ToSingle(textBox_Acc.Text));
        //       Zmcaux.ZAux_Direct_SetDecel(handle, axislist[0], Convert.ToSingle(textBox_Dec.Text));

        //        if (run_mode == 1)          //绝对
        //        {
        //            switch (move_mode)
        //            {
        //                case 1:     //XY直线
        //                   Zmcaux.ZAux_Direct_MoveAbs(handle, 2, axislist, poslist);
        //                    break;
        //                case 2:     //XY圆弧
        //                    Zmcaux.ZAux_Direct_MoveCirc2Abs(handle, 2, axislist, midlist[0], midlist[1], poslist[0], poslist[1]);
        //                    break;
        //                case 3:     //XYZ直线
        //                    Zmcaux.ZAux_Direct_MoveAbs(handle, 3, axislist, poslist);
        //                    break;
        //                case 4:      //空间圆弧 	XYZ空间圆弧插补U螺旋 没有绝对指令，需要用ENDMOVE_BUFF转相对
        //                    for (int i = 0; i < 4; i++)
        //                    {
        //                        Zmcaux.ZAux_Direct_GetEndMoveBuffer(handle, i, ref endmove[i]);	//计算相对位移
        //                        poslist[i] = poslist[i] - endmove[i];
        //                        midlist[i] = midlist[i] - endmove[i];
        //                    }

        //                    Zmcaux.ZAux_Direct_MSpherical(handle, 4, axislist, poslist[0], poslist[1], poslist[2], midlist[0], midlist[1], midlist[2], 0, poslist[3], 0);
        //                    break;
        //                default:
        //                    break;
        //            }

        //        }
        //        else
        //        {
        //            switch (move_mode)
        //            {
        //                case 1:
        //                    Zmcaux.ZAux_Direct_Move(handle, 2, axislist, poslist);
        //                    break;
        //                case 2:
        //                    Zmcaux.ZAux_Direct_MoveCirc2(handle, 2, axislist, midlist[0], midlist[1], poslist[0], poslist[1]);
        //                    break;
        //                case 3:
        //                    Zmcaux.ZAux_Direct_Move(handle, 4, axislist, poslist);
        //                    break;
        //                case 4:
        //                    Zmcaux.ZAux_Direct_MSpherical(handle, 4, axislist, poslist[0], poslist[1], poslist[2], midlist[0], midlist[1], midlist[2], 0, poslist[3], 0);
        //                    break;
        //                default:
        //                    break;
        //            }
        //        }
        //    }

        //    foreach (DataGridViewRow row in dataGridView1.Rows)
        //    {
        //        if (!row.IsNewRow)
        //        {
        //            // 模拟按照点位信息移动 
        //            double x = Convert.ToDouble(row.Cells["X"].Value);
        //            double y = Convert.ToDouble(row.Cells["Y"].Value);
        //            double z = Convert.ToDouble(row.Cells["Z"].Value);
        //            double u = Convert.ToDouble(row.Cells["U"].Value);
        //            // 这里应该添加实际的移动逻辑 
        //            Console.WriteLine($"移动到点位: P1点={x}, P2点={y}, P3点={z},P4点={u}");
        //        }
        //    }
        //}

        #endregion


        #region  停止加导入导出
        private void btnStop_Click(object sender, EventArgs e)
        {
            // 这里应该添加实际的停止移动逻辑 

            //获取规划轴的轴号
            var axis = GetPrfAxis();

            if (handle != IntPtr.Zero)
            {
                //停止规划轴对应运动
                ZAux_Direct_Single_Cancel(handle, axis, 2);


            }
            Console.WriteLine("停止轴移动");
        }

        private void btnImport_Click(object sender, EventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();//new一个打开文件控件
            //openFileDialog.InitialDirectory = Directory.GetCurrentDirectory();//设置初始目录
            //Console.WriteLine(openFileDialog.InitialDirectory.ToString());//获取初始目录

            openFileDialog.Filter = "CSV文件|*.csv";//设置文件类型  过滤器
            if (openFileDialog.ShowDialog() == DialogResult.OK)//判断是否选择了文件
            {
                string[] lines = File.ReadAllLines(openFileDialog.FileName);//读取文件内容
                dataGridView1.Rows.Clear();
                foreach (string line in lines)
                {
                    string[] values = line.Split(',');
                    dataGridView1.Rows.Add(values);
                }
            }
        }

        private void btnExport_Click(object sender, EventArgs e)
        {
            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.Filter = "CSV文件|*.csv";
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                using (StreamWriter sw = new StreamWriter(saveFileDialog.FileName))
                {
                    foreach (DataGridViewRow row in dataGridView1.Rows)
                    {
                        if (!row.IsNewRow)
                        {
                            List<string> values = new List<string>();
                            foreach (DataGridViewCell cell in row.Cells)
                            {
                                values.Add(cell.Value?.ToString() ?? "");
                            }
                            sw.WriteLine(string.Join(",", values));
                        }
                    }
                }
            }
        }

        #endregion


        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void Btn_left_Click(object sender, EventArgs e)
        {

        }

        private void Btn_left_continuous_Click(object sender, EventArgs e)
        {

        }
    }
}
      